{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "728352cc",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import testCases #参见资料包，或者在文章底部copy\n",
    "from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward #参见资料包\n",
    "import lr_utils #参见资料包，或者在文章底部copy\n",
    "# 指定随机种子\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac3e46e4",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 初始化参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "906328bb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def initialize_parameters(n_x, n_h, n_y):\n",
    "    '''\n",
    "    此函数是为了初始化两层网络参数而使用的函数。\n",
    "    参数：\n",
    "        n_x - 输入层节点数量\n",
    "        n_h - 隐藏层节点数量\n",
    "        n_y - 输出层节点数量\n",
    "\n",
    "    返回：\n",
    "        parameters - 包含你的参数的python字典：\n",
    "            W1 - 权重矩阵,维度为（n_h，n_x）\n",
    "            b1 - 偏向量，维度为（n_h，1）\n",
    "            W2 - 权重矩阵，维度为（n_y，n_h）\n",
    "            b2 - 偏向量，维度为（n_y，1）\n",
    "    '''\n",
    "    # 乘以0.01是防止梯度下降缓慢\n",
    "    W1 = np.random.randn(n_h, n_x) * 0.01\n",
    "    b1 = np.zeros((n_h, 1))\n",
    "    W2 = np.random.randn(n_y, n_h) * 0.01\n",
    "    b2 = np.zeros((n_y, 1))\n",
    "\n",
    "    # 使用断言来确保我的数据格式是正确的\n",
    "    assert(W1.shape == (n_h ,n_x))\n",
    "    assert(b1.shape == (n_h, 1))\n",
    "    assert(W2.shape == (n_y, n_h))\n",
    "    assert(b2.shape == (n_y, 1))\n",
    "\n",
    "    parameters = {\n",
    "        \"W1\": W1,\n",
    "        \"b1\": b1,\n",
    "        \"W2\": W2,\n",
    "        \"b2\": b2\n",
    "    }\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6d500bc5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def initialize_parameters_deep(layers_dims):\n",
    "    '''\n",
    "    此函数是为了初始化多层网络参数而使用的函数。\n",
    "    参数：\n",
    "        layers_dims - 包含我们网络中每个图层的节点数量的列表\n",
    "\n",
    "    返回：\n",
    "        parameters - 包含参数“W1”，“b1”，...，“WL”，“bL”的字典：\n",
    "                     W1 - 权重矩阵，维度为（layers_dims [1]，layers_dims [1-1]）\n",
    "                     bl - 偏向量，维度为（layers_dims [1]，1）\n",
    "    '''\n",
    "    # 设置随机种子，来控制结果稳定\n",
    "    np.random.seed(3)\n",
    "    parameters = {}  #承载参数\n",
    "    L = len(layers_dims)  #确定隐藏层层数\n",
    "\n",
    "    # 隐藏层层数比传入的参数少一，不包括输入层和输出层\n",
    "    # 随机初始化参数\n",
    "    for l in range(1, L):\n",
    "        parameters['W'+str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) / np.sqrt(layers_dims[l-1])\n",
    "        parameters['b'+str(l)] = np.zeros((layers_dims[l], 1))\n",
    "\n",
    "        # 确保数据格式正确\n",
    "        assert(parameters['W'+str(l)].shape == (layers_dims[l], layers_dims[l-1]))\n",
    "        assert(parameters['b'+str(l)].shape == (layers_dims[l], 1))\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2aceb6",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 前向传播分\n",
    "分两步，同时保存A_pre,w,b,Z,A\n",
    "- 线性前向传播\n",
    "- 激活函数前向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3d5a7678",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def linear_forward(A, W, b):\n",
    "    '''\n",
    "    实现前向传播的线性部分。\n",
    "    参数：\n",
    "        A - 来自上一层（或输入数据）的激活，维度为(上一层的节点数量，示例的数量）\n",
    "        W - 权重矩阵，numpy数组，维度为（当前图层的节点数量，前一图层的节点数量）\n",
    "        b - 偏向量，numpy向量，维度为（当前图层节点数量，1）\n",
    "    返回：\n",
    "         Z - 激活功能的输入，也称为预激活参数\n",
    "         cache - 一个包含“A”，“W”和“b”的字典，存储这些变量以有效地计算后向传递\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    Z = np.dot(W, A) + b  #计算输入\n",
    "    # 确保数据格式正确\n",
    "    assert(Z.shape == (W.shape[0], A.shape[1]))\n",
    "    cache = (A, W, b)\n",
    "\n",
    "    return Z, cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f3df5afc",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def linear_activation_forward(A_prev, W, b, activation):\n",
    "    '''\n",
    "    实现LINEAR-> ACTIVATION 这一层的前向传播\n",
    "    参数：\n",
    "        A_prev - 来自上一层（或输入层）的激活，维度为(上一层的节点数量，示例数）\n",
    "        W - 权重矩阵，numpy数组，维度为（当前层的节点数量，前一层的大小）\n",
    "        b - 偏向量，numpy阵列，维度为（当前层的节点数量，1）\n",
    "        activation - 选择在此层中使用的激活函数名，字符串类型，【\"sigmoid\" | \"relu\"】\n",
    "    返回：\n",
    "        A - 激活函数的输出，也称为激活后的值\n",
    "        cache - 一个包含“linear_cache”和“activation_cache”的字典，我们需要存储它以有效地计算后向传递\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    # 区分不同的激活函数\n",
    "    if activation == 'sigmoid':\n",
    "        # 前向传播\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = sigmoid(Z)\n",
    "    elif activation == 'relu':\n",
    "        Z, linear_cache = linear_forward(A_prev, W, b)\n",
    "        A, activation_cache = relu(Z)\n",
    "\n",
    "    #确保数据格式正确\n",
    "    assert(A.shape == (W.shape[0], A_prev.shape[1]))\n",
    "    cache = (linear_cache, activation_cache)\n",
    "\n",
    "    return A,cache"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d97e083",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## model的前向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c4881af5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def L_model_forward(X, parameters):\n",
    "    '''\n",
    "    实现[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID计算前向传播，也就是多层网络的前向传播，为后面每一层都执行LINEAR和ACTIVATION\n",
    "\n",
    "    参数：\n",
    "        X - 数据，numpy数组，维度为（输入节点数量，示例数）\n",
    "        parameters - initialize_parameters_deep（）的输出\n",
    "\n",
    "    返回：\n",
    "        AL - 最后的激活值\n",
    "        caches - 包含以下内容的缓存列表：\n",
    "                 linear_relu_forward（）的每个cache（有L-1个，索引为从0到L-2）\n",
    "                 linear_sigmoid_forward（）的cache（只有一个，索引为L-1）\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    # 结果存储\n",
    "    caches = []\n",
    "    A = X\n",
    "    L = len(parameters) // 2\n",
    "\n",
    "    # 神经网络结构\n",
    "    # 前面使用relu激活函数，最后一层使用sigmoid函数\n",
    "    for l in range(1, L):\n",
    "        A_prev = A\n",
    "        A, cache = linear_activation_forward(A_prev, parameters['W'+str(l)], parameters['b'+str(l)], 'relu')\n",
    "        caches.append(cache)\n",
    "\n",
    "    AL, cache = linear_activation_forward(A, parameters['W'+str(L)],\\\n",
    "                                         parameters['b'+str(L)], 'sigmoid')\n",
    "    caches.append(cache)\n",
    "\n",
    "    # 确保数据格式正确\n",
    "    assert(AL.shape == (1, X.shape[1]))\n",
    "\n",
    "    return AL, caches"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eda05d9b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 计算cost function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e148da0a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def compute_cost(AL, Y):\n",
    "    '''\n",
    "    实施等式（4）定义的成本函数。\n",
    "    参数：\n",
    "        AL - 与标签预测相对应的概率向量，维度为（1，示例数量）\n",
    "        Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）\n",
    "    返回：\n",
    "        cost - 交叉熵成本\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    # 样本数量m\n",
    "    m = Y.shape[1]\n",
    "    cost = -np.sum(np.multiply(np.log(AL), Y)+np.multiply(np.log(1-AL),\\\n",
    "                                    1-Y))/m\n",
    "    # 压缩数据\n",
    "    cost = np.squeeze(cost)\n",
    "    # 确认数据格式\n",
    "    assert(cost.shape == ())\n",
    "\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afebb6d7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 反向传播\n",
    "-反向传播用于计算相对于参数的损失函数的梯度，向前和向后传播的流程图如下：\n",
    "![](./backpropgation1.png)\n",
    "- 对于线性的部分的公式\n",
    "![](./backpropgation2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "978ce594",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def linear_backward(dZ, cache):\n",
    "    '''\n",
    "    为单层实现反向传播的线性部分（第L层）\n",
    "    参数：\n",
    "         dZ - 相对于（当前第l层的）线性输出的成本梯度\n",
    "         cache - 来自当前层前向传播的值的元组（A_prev，W，b）\n",
    "    返回：\n",
    "         dA_prev - 相对于激活（前一层l-1）的成本梯度，与A_prev维度相同\n",
    "         dW - 相对于W（当前层l）的成本梯度，与W的维度相同\n",
    "         db - 相对于b（当前层l）的成本梯度，与b维度相同\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    A_prev, W, b = cache\n",
    "    m = A_prev.shape[1]\n",
    "    dW = np.dot(dZ, A_prev.T) / m\n",
    "    db = np.sum(dZ, axis=1, keepdims=True) / m\n",
    "    dA_prev = np.dot(W.T, dZ)\n",
    "\n",
    "    # 确认数据格式正确\n",
    "    assert(dA_prev.shape == A_prev.shape)\n",
    "    assert(dW.shape == W.shape)\n",
    "    assert(db.shape == b.shape)\n",
    "\n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a2ce0ec3",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def linear_activation_backward(dA, cache, activation='relu'):\n",
    "    '''\n",
    "    实现LINEAR-> ACTIVATION层的后向传播。\n",
    "\n",
    "    参数：\n",
    "         dA - 当前层l的激活后的梯度值\n",
    "         cache - 我们存储的用于有效计算反向传播的值的元组（值为linear_cache，activation_cache）\n",
    "         activation - 要在此层中使用的激活函数名，字符串类型，【\"sigmoid\" | \"relu\"】\n",
    "    返回：\n",
    "         dA_prev - 相对于激活（前一层l-1）的成本梯度值，与A_prev维度相同\n",
    "         dW - 相对于W（当前层l）的成本梯度值，与W的维度相同\n",
    "         db - 相对于b（当前层l）的成本梯度值，与b的维度相同\n",
    "    '''\n",
    "    #Please do something\n",
    "    # 获取参数\n",
    "    linear_cache, actvation_cache = cache\n",
    "    # 不同的激活函数的导数也不同\n",
    "    if activation == 'relu':\n",
    "        dZ = relu_backward(dA, actvation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "    elif activation == 'sigmoid':\n",
    "        dZ = sigmoid_backward(dA, actvation_cache)\n",
    "        dA_prev, dW, db = linear_backward(dZ, linear_cache)\n",
    "\n",
    "    return dA_prev, dW, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fe1452de",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def L_model_backward(AL, Y, caches):\n",
    "    '''\n",
    "    对[LINEAR-> RELU] *（L-1） - > LINEAR - > SIGMOID组执行反向传播，就是多层网络的向后传播\n",
    "\n",
    "    参数：\n",
    "     AL - 概率向量，正向传播的输出（L_model_forward（））\n",
    "     Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）\n",
    "     caches - 包含以下内容的cache列表：\n",
    "                 linear_activation_forward（\"relu\"）的cache，不包含输出层\n",
    "                 linear_activation_forward（\"sigmoid\"）的cache\n",
    "\n",
    "    返回：\n",
    "     grads - 具有梯度值的字典\n",
    "              grads [“dA”+ str（l）] = ...\n",
    "              grads [“dW”+ str（l）] = ...\n",
    "              grads [“db”+ str（l）] = ...\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    # 初始化参数\n",
    "    grads = {}\n",
    "    L = len(caches)\n",
    "    m = AL.shape[1]\n",
    "    Y = Y.reshape(AL.shape)\n",
    "    dAL = -(np.divide(Y, AL)-np.divide(1-Y, 1-AL))\n",
    "\n",
    "    current_cache = caches[L-1]\n",
    "    grads['dA'+str(L)], grads['dW'+str(L)], grads['db'+str(L)] = \\\n",
    "    linear_activation_backward(dAL, current_cache, 'sigmoid')\n",
    "\n",
    "    # 逐层进行反向传播\n",
    "    for l in reversed(range(L-1)):\n",
    "        current_cache = caches[l]  #当前层\n",
    "        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads['dA'+\\\n",
    "                                    str(l+2)], current_cache, 'relu')\n",
    "        grads['dA'+str(l+1)] = dA_prev_temp\n",
    "        grads['dW'+str(l+1)] = dW_temp\n",
    "        grads['db'+str(l+1)] = db_temp\n",
    "\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dW1 = [[0.41010002 0.07807203 0.13798444 0.10502167]\n",
      " [0.         0.         0.         0.        ]\n",
      " [0.05283652 0.01005865 0.01777766 0.0135308 ]]\n",
      "db1 = [[-0.22007063]\n",
      " [ 0.        ]\n",
      " [-0.02835349]]\n",
      "dA1 = [[ 0.          0.52257901]\n",
      " [ 0.         -0.3269206 ]\n",
      " [ 0.         -0.32070404]\n",
      " [ 0.         -0.74079187]]\n"
     ]
    }
   ],
   "source": [
    "AL, Y_assess, caches = testCases.L_model_backward_test_case()\n",
    "grads = L_model_backward(AL, Y_assess, caches)\n",
    "print (\"dW1 = \"+ str(grads[\"dW1\"]))\n",
    "print (\"db1 = \"+ str(grads[\"db1\"]))\n",
    "print (\"dA1 = \"+ str(grads[\"dA1\"]))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "id": "526304e0",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 更新参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0e4d5aca",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def update_parameters(parameters, grads, learning_rate):\n",
    "    \"\"\"\n",
    "    使用梯度下降更新参数\n",
    "\n",
    "    参数：\n",
    "     parameters - 包含你的参数的字典\n",
    "     grads - 包含梯度值的字典，是L_model_backward的输出\n",
    "    \n",
    "    返回：\n",
    "     parameters - 包含更新参数的字典\n",
    "                   参数[“W”+ str（l）] = ...\n",
    "                   参数[“b”+ str（l）] = ...\n",
    "    \"\"\"\n",
    "    L = len(parameters) // 2 #整除\n",
    "    for l in range(L):\n",
    "        parameters[\"W\" + str(l + 1)] = parameters[\"W\" + str(l + 1)] - learning_rate * grads[\"dW\" + str(l + 1)]\n",
    "        parameters[\"b\" + str(l + 1)] = parameters[\"b\" + str(l + 1)] - learning_rate * grads[\"db\" + str(l + 1)]\n",
    "        \n",
    "    return parameters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2679152c",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 搭建两层神经网络\n",
    "- 两层的神经网络模型图如下:\n",
    "![](./twoLayersNN.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e2abf25",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 两层神经网络建模及参数学习"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c3bb54d0",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Relu激活函数\n",
    "def two_layer_model(X, Y, layers_dims, learning_rate=0.0075, \\\n",
    "        num_iterations=3000, print_cost=False, isPlot=True):\n",
    "    '''\n",
    "    实现一个两层的神经网络，【LINEAR->RELU】 -> 【LINEAR->SIGMOID】\n",
    "    参数：\n",
    "        X - 输入的数据，维度为(n_x，例子数)\n",
    "        Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)\n",
    "        layers_dims - 层数的向量，维度为(n_y,n_h,n_y)\n",
    "        learning_rate - 学习率\n",
    "        num_iterations - 迭代的次数\n",
    "        print_cost - 是否打印成本值，每100次打印一次\n",
    "        isPlot - 是否绘制出误差值的图谱\n",
    "    返回:\n",
    "        parameters - 一个包含W1，b1，W2，b2的字典变量\n",
    "    '''\n",
    "    #Please do something\n",
    "\n",
    "    # 设置随机种子，保证结果可复现\n",
    "    np.random.seed(1)\n",
    "    '''\n",
    "    初始化参数\n",
    "    '''\n",
    "    grads = {}\n",
    "    costs = []\n",
    "    (n_x, n_h, n_y) = layers_dims\n",
    "\n",
    "    parameters = initialize_parameters(n_x, n_h, n_y)\n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "\n",
    "    # 开始进行迭代\n",
    "    for i in range(num_iterations):\n",
    "        # 前向传播\n",
    "        A1, cache1 = linear_activation_forward(X, W1, b1, 'relu')\n",
    "        A2, cache2 = linear_activation_forward(A1, W2, b2, 'sigmoid')\n",
    "\n",
    "        # 计算成本\n",
    "        cost = compute_cost(A2, Y)\n",
    "\n",
    "        # 后向传播\n",
    "        # 初始化后向传播\n",
    "        dA2 = -(np.divide(Y, A2) - np.divide(1-Y, 1-A2))\n",
    "\n",
    "        # 后向传播\n",
    "        dA1, dW2, db2 = linear_activation_backward(dA2, cache2, 'sigmoid')\n",
    "        dA0, dW1, db1 = linear_activation_backward(dA1, cache1, 'relu')\n",
    "\n",
    "        # 向后传播的数据保存到grads\n",
    "        grads['dW1'] = dW1\n",
    "        grads['db1'] = db1\n",
    "        grads['dW2'] = dW2\n",
    "        grads['db2'] = db2\n",
    "\n",
    "        # 更新参数\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "        W1 = parameters['W1']\n",
    "        b1 = parameters['b1']\n",
    "        W2 = parameters['W2']\n",
    "        b2 = parameters['b2']\n",
    "\n",
    "        # 打印成本值，如果print_cost=False则被忽略\n",
    "        if i%100 == 0:\n",
    "            #记录成本\n",
    "            costs.append(cost)\n",
    "            if print_cost:\n",
    "                print('第',i,'次迭代，成本值为：', np.squeeze(cost))\n",
    "\n",
    "     #迭代完成，则根据条件进行绘制图\n",
    "    if isPlot:\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title('Learing rate = '+str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "    # 返回参数parameters\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "train_x_orig, train_y, test_x_orig, test_y, classes = lr_utils.load_dataset()\n",
    "\n",
    "m_train = train_x_orig.shape[0] # 训练样本的数量\n",
    "m_test = test_x_orig.shape[0] # 测试样本的数量\n",
    "num_px = test_x_orig.shape[1] # 每张图片的宽/高\n",
    "\n",
    "# 为了方便后面进行矩阵运算，我们需要将样本数据进行扁平化和转置\n",
    "# 处理后的数组各维度的含义是（图片数据，样本数）\n",
    "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T\n",
    "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n",
    "\n",
    "# 下面我们对特征数据进行了简单的标准化处理（除以255，使所有值都在[0，1]范围内）\n",
    "train_x = train_x_flatten/255.\n",
    "test_x = test_x_flatten/255."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第 0 次迭代，成本值为： 0.6930497356599891\n",
      "第 100 次迭代，成本值为： 0.6464320953428849\n",
      "第 200 次迭代，成本值为： 0.6325140647912676\n",
      "第 300 次迭代，成本值为： 0.6015024920354665\n",
      "第 400 次迭代，成本值为： 0.5601966311605747\n",
      "第 500 次迭代，成本值为： 0.5158304772764732\n",
      "第 600 次迭代，成本值为： 0.4754901313943326\n",
      "第 700 次迭代，成本值为： 0.43391631512257517\n",
      "第 800 次迭代，成本值为： 0.4007977536203885\n",
      "第 900 次迭代，成本值为： 0.35807050113237915\n",
      "第 1000 次迭代，成本值为： 0.3394281538366412\n",
      "第 1100 次迭代，成本值为： 0.305275363619627\n",
      "第 1200 次迭代，成本值为： 0.2749137728213022\n",
      "第 1300 次迭代，成本值为： 0.24681768210614743\n",
      "第 1400 次迭代，成本值为： 0.1985073503746613\n",
      "第 1500 次迭代，成本值为： 0.1744831811255645\n",
      "第 1600 次迭代，成本值为： 0.17080762978094413\n",
      "第 1700 次迭代，成本值为： 0.11306524562164803\n",
      "第 1800 次迭代，成本值为： 0.09629426845937157\n",
      "第 1900 次迭代，成本值为： 0.0834261795972689\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 设置好深度神经网络的层次信息——下面代表了一个4层的神经网络（12288是输入层），\n",
    "# 第一层有20个神经元，第二层有7个神经元。。。\n",
    "# 你也可以构建任意层任意神经元数量的神经网络，只需要更改下面这个数组就可以了\n",
    "layers_dims = [12288, 7, 1]\n",
    "# 根据上面的层次信息来构建一个深度神经网络，并且用之前加载的数据集来训练这个神经网络，得出训练后的参数\n",
    "parameters = two_layer_model(train_x, train_y, layers_dims, num_iterations=2000, print_cost=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "id": "b740463e",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 测试两层神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de620586",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "094977de",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = lr_utils.load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fb0711bc",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "(209, 64, 64, 3)"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_orig.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fe7ab154",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "(1, 209)"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "62abd355",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.image.AxesImage at 0x1902943cf48>"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(train_set_x_orig[50])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "59758ac7",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#样本向量化\n",
    "train_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T \n",
    "test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7eeba45e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "(12288, 209)"
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x_flatten.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dbdf6634",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_x = train_x_flatten / 255\n",
    "train_y = train_set_y\n",
    "test_x = test_x_flatten / 255\n",
    "test_y = test_set_y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee3eba7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 测试模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7fa7441d",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第 0 次迭代，成本值为： 0.6930497356599891\n",
      "第 100 次迭代，成本值为： 0.6464320953428849\n",
      "第 200 次迭代，成本值为： 0.6325140647912676\n",
      "第 300 次迭代，成本值为： 0.6015024920354665\n",
      "第 400 次迭代，成本值为： 0.5601966311605747\n",
      "第 500 次迭代，成本值为： 0.5158304772764732\n",
      "第 600 次迭代，成本值为： 0.4754901313943326\n",
      "第 700 次迭代，成本值为： 0.43391631512257517\n",
      "第 800 次迭代，成本值为： 0.4007977536203885\n",
      "第 900 次迭代，成本值为： 0.35807050113237915\n",
      "第 1000 次迭代，成本值为： 0.3394281538366412\n",
      "第 1100 次迭代，成本值为： 0.305275363619627\n",
      "第 1200 次迭代，成本值为： 0.2749137728213022\n",
      "第 1300 次迭代，成本值为： 0.24681768210614743\n",
      "第 1400 次迭代，成本值为： 0.1985073503746613\n",
      "第 1500 次迭代，成本值为： 0.1744831811255645\n",
      "第 1600 次迭代，成本值为： 0.17080762978094413\n",
      "第 1700 次迭代，成本值为： 0.11306524562164803\n",
      "第 1800 次迭代，成本值为： 0.09629426845937157\n",
      "第 1900 次迭代，成本值为： 0.0834261795972689\n",
      "第 2000 次迭代，成本值为： 0.07439078704319094\n",
      "第 2100 次迭代，成本值为： 0.06630748132267916\n",
      "第 2200 次迭代，成本值为： 0.059193295010381605\n",
      "第 2300 次迭代，成本值为： 0.05336140348560558\n",
      "第 2400 次迭代，成本值为： 0.04855478562877011\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_x = 12288\n",
    "n_h = 7\n",
    "n_y = 1\n",
    "layers_dims = (n_x,n_h,n_y)\n",
    "\n",
    "parameters = two_layer_model(train_x, train_set_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True,isPlot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cfaa9c2",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 模型预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "259dc119",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def predict(X, y, parameters):\n",
    "    \"\"\"\n",
    "    该函数用于预测L层神经网络的结果，当然也包含两层\n",
    "\n",
    "    参数：\n",
    "     X - 测试集\n",
    "     y - 标签\n",
    "     parameters - 训练模型的参数\n",
    "\n",
    "    返回：\n",
    "     p - 给定数据集X的预测\n",
    "    \"\"\"\n",
    "\n",
    "    m = X.shape[1]\n",
    "    n = len(parameters) // 2 # 神经网络的层数\n",
    "    p = np.zeros((1,m))\n",
    "\n",
    "    #根据参数前向传播\n",
    "    probas, caches = L_model_forward(X, parameters)\n",
    "\n",
    "    for i in range(0, probas.shape[1]):\n",
    "        if probas[0,i] > 0.5:\n",
    "            p[0,i] = 1\n",
    "        else:\n",
    "            p[0,i] = 0\n",
    "\n",
    "    print(\"准确度为: \"  + str(float(np.sum((p == y))/m)))\n",
    "\n",
    "    return p\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f972d7fa",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "准确度为: 1.0\n",
      "准确度为: 0.72\n"
     ]
    }
   ],
   "source": [
    "predictions_train = predict(train_x, train_y, parameters) #训练集\n",
    "predictions_test = predict(test_x, test_y, parameters) #测试集"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac51566",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 搭建多层神经网络\n",
    "多层的网络的结构：\n",
    "![](./deepLayersNN.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64bfef7a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 多层神经网络建模及参数学习"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "684c12f1",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 多层神经网络建模"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7031468e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000,\\\n",
    "                 print_cost=False, isPlot=False):\n",
    "    '''\n",
    "    实现一个L层神经网络：[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID。\n",
    "\n",
    "    参数：\n",
    "        X - 输入的数据，维度为(n_x，例子数)\n",
    "        Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)\n",
    "        layers_dims - 层数的向量，维度为(n_y,n_h,···,n_h,n_y)\n",
    "        learning_rate - 学习率\n",
    "        num_iterations - 迭代的次数\n",
    "        print_cost - 是否打印成本值，每100次打印一次\n",
    "        isPlot - 是否绘制出误差值的图谱\n",
    "\n",
    "    返回：\n",
    "     parameters - 模型学习的参数。 然后他们可以用来预测。\n",
    "    '''\n",
    "\n",
    "    #Please do something\n",
    "\n",
    "    # 设置随机数种子，保证结果一致性\n",
    "    np.random.seed(1)\n",
    "    costs = []\n",
    "\n",
    "    # 随机初始化网络参数\n",
    "    parameters = initialize_parameters_deep(layers_dims)\n",
    "\n",
    "    for i in range(0, num_iterations):\n",
    "        # 前向传播\n",
    "        AL, caches = L_model_forward(X, parameters)\n",
    "        # 计算代价函数\n",
    "        cost = compute_cost(AL, Y)\n",
    "        # 反向传播\n",
    "        grads = L_model_backward(AL, Y, caches)\n",
    "        # 梯度下降\n",
    "        parameters = update_parameters(parameters, grads, learning_rate)\n",
    "\n",
    "        #打印成本值，如果print_cost = False则省略\n",
    "        if i%100 == 0:\n",
    "            # 记录成本\n",
    "            costs.append(cost)\n",
    "            # 是否打印成本值\n",
    "            if print_cost:\n",
    "                print(\"第\",i,\"次迭代，成本值为：\", np.squeeze(cost))\n",
    "\n",
    "    # 迭代完成，根据条件绘制图\n",
    "    if isPlot:\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title('Learning rate = '+str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbb3a9d7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 测试多层神经网络\n",
    "### 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "93fac424",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = lr_utils.load_dataset()\n",
    "\n",
    "train_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T \n",
    "test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
    "\n",
    "train_x = train_x_flatten / 255\n",
    "train_y = train_set_y\n",
    "test_x = test_x_flatten / 255\n",
    "test_y = test_set_y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d76d8804",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 测试模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "79efeab0",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第 0 次迭代，成本值为： 0.715731513413713\n",
      "第 100 次迭代，成本值为： 0.6747377593469114\n",
      "第 200 次迭代，成本值为： 0.6603365433622126\n",
      "第 300 次迭代，成本值为： 0.6462887802148751\n",
      "第 400 次迭代，成本值为： 0.6298131216927774\n",
      "第 500 次迭代，成本值为： 0.606005622926534\n",
      "第 600 次迭代，成本值为： 0.5690041263975134\n",
      "第 700 次迭代，成本值为： 0.519796535043806\n",
      "第 800 次迭代，成本值为： 0.464157167862823\n",
      "第 900 次迭代，成本值为： 0.4084203004829893\n",
      "第 1000 次迭代，成本值为： 0.37315499216069037\n",
      "第 1100 次迭代，成本值为： 0.3057237457304713\n",
      "第 1200 次迭代，成本值为： 0.2681015284774086\n",
      "第 1300 次迭代，成本值为： 0.2387247482767257\n",
      "第 1400 次迭代，成本值为： 0.20632263257914704\n",
      "第 1500 次迭代，成本值为： 0.17943886927493516\n",
      "第 1600 次迭代，成本值为： 0.15798735818801002\n",
      "第 1700 次迭代，成本值为： 0.14240413012273673\n",
      "第 1800 次迭代，成本值为： 0.12865165997884462\n",
      "第 1900 次迭代，成本值为： 0.11244314998151156\n",
      "第 2000 次迭代，成本值为： 0.08505631034959031\n",
      "第 2100 次迭代，成本值为： 0.05758391198600472\n",
      "第 2200 次迭代，成本值为： 0.04456753454691302\n",
      "第 2300 次迭代，成本值为： 0.0380827516659641\n",
      "第 2400 次迭代，成本值为： 0.034410749018394936\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "layers_dims = [12288, 20, 7, 5, 1] #  5-layer model\n",
    "parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True,isPlot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3267cc22",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "准确度为: 0.9952153110047847\n",
      "准确度为: 0.78\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, train_y, parameters) #训练集\n",
    "pred_test = predict(test_x, test_y, parameters) #测试集"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69b6a0fe",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 模型分析\n",
    "看一看有哪些东西在L层模型中被错误地标记了，导致准确率没有提高。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a10eb796",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2880x2880 with 11 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def print_mislabeled_images(classes, X, y, p):\n",
    "    \"\"\"\n",
    "    绘制预测和实际不同的图像。\n",
    "        X - 数据集\n",
    "        y - 实际的标签\n",
    "        p - 预测\n",
    "    \"\"\"\n",
    "    a = p + y\n",
    "    mislabeled_indices = np.asarray(np.where(a == 1))\n",
    "    plt.rcParams['figure.figsize'] = (40.0, 40.0) # set default size of plots\n",
    "    num_images = len(mislabeled_indices[0])\n",
    "    for i in range(num_images):\n",
    "        index = mislabeled_indices[1][i]\n",
    "        \n",
    "        plt.subplot(2, num_images, i + 1)\n",
    "        plt.imshow(X[:,index].reshape(64,64,3), interpolation='nearest')\n",
    "        plt.axis('off')\n",
    "        plt.title(\"Prediction: \" + classes[int(p[0,index])].decode(\"utf-8\") + \" \\n Class: \" + classes[y[0,index]].decode(\"utf-8\"))\n",
    "\n",
    "\n",
    "print_mislabeled_images(classes, test_x, test_y, pred_test)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836deab0",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "分析一下可以得知原因：\n",
    "\n",
    "模型往往表现欠佳的几种类型的图像包括：\n",
    "\n",
    "    猫身体在一个不同的位置\n",
    "    猫出现在相似颜色的背景下\n",
    "    不同的猫的颜色和品种\n",
    "    相机角度\n",
    "    图片的亮度\n",
    "    比例变化（猫的图像非常大或很小）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9dd3037",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 真实样本测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "bd7ff0da",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "def myLoadImgAndResize(img_path,width,height):\n",
    "    image = Image.open(img_file_path)\n",
    "    \n",
    "    img = image.resize((width,height),Image.ANTIALIAS)\n",
    "    \n",
    "    img_arr = np.array(img)\n",
    "    \n",
    "    return img_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "448b1c97",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def myPredict(img_path,label,width,height):\n",
    "    img = myLoadImgAndResize(img_file_path,width,height)\n",
    "    plt.imshow(img)\n",
    "    my_image_x = img.reshape(1,-1).T\n",
    "    my_image_y = [label]\n",
    "    \n",
    "    predic_res = predict(my_image_x, my_image_y, parameters)\n",
    "    print(predic_res)\n",
    "    print (\"y = \" + str(np.squeeze(predic_res)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(predic_res)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "989c14f2",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: ANTIALIAS is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.LANCZOS instead.\n",
      "  import sys\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "准确度为: 1.0\n",
      "[[1.]]\n",
      "y = 1.0, your L-layer model predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 2880x2880 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_file_path = \"datasets/myCat8.jpg\"\n",
    "num_px = 64\n",
    "myPredict(img_file_path,1,num_px,num_px)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}